home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / c / recio202.zip / testchg.c < prev    next >
C/C++ Source or Header  |  1994-05-05  |  10KB  |  312 lines
  1. /* testchg.c - tests character delimited get functions */
  2. /* recio version 2.02, release May 5, 1994 */
  3. /* Copyright (C) 1994 William Pierpoint */
  4.  
  5. #include <ctype.h>
  6. #include <errno.h>
  7. #include <limits.h>
  8. #include <float.h>
  9. #include <stdio.h>
  10. #include <stdlib.h>
  11. #include <string.h>
  12.  
  13. #include "recio.h"
  14.  
  15. /* errors normally to stderr; but for test purposes, stdout */
  16. #define errout  stdout
  17.  
  18. /****************************************************************************
  19. Dynamic string copy function, kludged for use with recio.  This 
  20. function is not part of recio nor was rseterr() designed to work 
  21. with it, but you get the idea.  
  22. Precondition: set dst to null ptr when declaring it, e.g. char *dst=NULL;
  23. Syntax: the assignment operator is mandatory, i.e. dst=scopys(dst, src);
  24. Obligation: free dst when finished with it.
  25. *****************************************************************************/
  26. char *                  /* return dst                                       */
  27.     scopys(             /* copy string dynamically                          */
  28.         char *dst,      /* destination string pointer                       */
  29.         char *src)      /* source string pointer                            */
  30. /****************************************************************************/
  31. {                       
  32.   size_t dlen;          /* strlen of dst */
  33.   size_t slen;          /* strlen of src */
  34.   int errnum;           /* error number */
  35.  
  36.   /* if null src pointer */
  37.   if (!src) {
  38.     rseterr(NULL, EINVAL);
  39.     dst = NULL;
  40.     goto done;
  41.   }
  42.   
  43.   if (dst) {
  44.     dlen = strlen(dst);
  45.     slen = strlen(src);
  46.     if (dlen < slen) {
  47.       do {
  48.         dst = (char *) realloc(dst, slen+1);
  49.         if (!dst) {
  50.           errnum = rseterr(NULL, ENOMEM);
  51.           if (errnum) goto done;
  52.         }
  53.       } while (!dst);
  54.     }
  55.     strcpy(dst, src);
  56.   } else {
  57.      do {
  58.        dst = strdup(src);
  59.        if (!dst) {
  60.          errnum = rseterr(NULL, ENOMEM);
  61.          if (errnum) goto done;
  62.        }
  63.      } while (!dst);
  64.    }
  65. done:
  66.   return dst;
  67. }
  68.  
  69. /****************************************************************************/
  70. void                         /* return nothing                              */
  71.     rfixnum(                 /* fix number                                  */
  72.         REC *rp,             /* record pointer                              */
  73.         int  errnum,         /* error number                                */
  74.         int (*rfix)(REC *))  /* rfix function pointer                       */
  75. /****************************************************************************/
  76. {
  77.   switch (errnum) {
  78.   case R_EMISDAT:
  79.     fprintf(errout, "...substituting zero\n");
  80.     rsetfldstr(rp, "0");
  81.     break;
  82.   case R_EINVDAT:
  83.   case R_ERANGE:
  84.     fprintf(errout, "...substituting best guess\n");
  85.     rfix(rp);
  86.     break;
  87.   }
  88. }
  89.  
  90. /****************************************************************************/
  91. void                         /* return nothing                              */
  92.     rfixchar(                /* fix character                               */
  93.         REC *rp,             /* record pointer                              */
  94.         int  errnum,         /* error number                                */
  95.         int (*rfix)(REC *))  /* rfix function pointer                       */
  96. /****************************************************************************/
  97. {
  98.   switch (errnum) {
  99.   case R_EMISDAT:
  100.     fprintf(errout, "...substituting the letter N\n");
  101.     rsetfldstr(rp, "N");
  102.     break;
  103.   case R_EINVDAT:
  104.     fprintf(errout, "...substituting best guess\n");
  105.     rfix(rp);
  106.     break;
  107.   }
  108. }
  109.  
  110. /****************************************************************************/
  111. void                         /* returns nothing                             */
  112.     rwarnfn(                 /* recio callback warning function             */
  113.         REC *rp)             /* record pointer                              */
  114. /****************************************************************************/
  115. {
  116.   if (risvalid(rp)) {
  117.     switch (rwarning(rp)) {
  118.     case R_WNOREG:   /* atexit() full */
  119.       fprintf (errout, "WARNING %s\n", rwarnstr(rp));
  120.       break;
  121.     case R_WEMPSTR:  /* empty data string */
  122.       fprintf(errout, "WARNING reading %s at record %lu and field %u -- %s\n", 
  123.        rnames(rp), rrecno(rp), rfldno(rp), rwarnstr(rp));
  124.       break;
  125.     }
  126.   }
  127. }
  128.  
  129. /****************************************************************************/
  130. void                         /* returns nothing                             */
  131.     rerrfn(                  /* recio callback error function               */
  132.         REC *rp)             /* record pointer                              */
  133. /****************************************************************************/
  134. {
  135.   int errnum;       /* error number */
  136.  
  137.   if (risvalid(rp)) {
  138.   
  139.     /* if reof indicator set */
  140.     if (reof(rp)) { 
  141.       fprintf(errout, "ERROR reading %s: "
  142.        "tried to read past end of file\n", rnames(rp));
  143.     
  144.     /* else rerror indicator set */
  145.     } else {
  146.  
  147.       /* determine cause of error */
  148.       errnum = rerror(rp);
  149.       switch (errnum) {
  150.  
  151.       /* data errors */
  152.       case R_ERANGE:   /* data out of range */
  153.       case R_EINVDAT:  /* invalid data */
  154.       case R_EMISDAT:  /* missing data */
  155.         fprintf(errout, "DATA ERROR reading %s at record %lu and field %u "
  156.          "-- %s\n", rnames(rp), rrecno(rp), rfldno(rp), rerrstr(rp));
  157.           
  158.         /* determine context */
  159.         switch (rcxtno(rp)) {
  160.         case RECIN:
  161.           
  162.           /* determine field */
  163.           switch (rfldno(rp)) {
  164.           case 1:  /* the integer field i */
  165.             rfixnum(rp, errnum, rfixi);
  166.             break;
  167.           
  168.           case 2:  /* the unsigned integer field ui */
  169.             rfixnum(rp, errnum, rfixui);
  170.             break;
  171.  
  172.            case 3:  /* the long field l */
  173.             rfixnum(rp, errnum, rfixl);
  174.             break;
  175.  
  176.            case 4:  /* the unsigned long field ul */
  177.             rfixnum(rp, errnum, rfixul);
  178.             break;
  179.  
  180.            case 5:  /* the float field f */
  181.             rfixnum(rp, errnum, rfixf);
  182.             break;
  183.  
  184.           case 6:  /* the double field d */
  185.             rfixnum(rp, errnum, rfixd);
  186.             break;
  187.  
  188.           case 7: /* the character field ch */
  189.             rfixchar(rp, errnum, rfixc);
  190.             break;
  191.  
  192.           default: /* programming error - no case for field */
  193.             fprintf(errout, "FATAL ERROR %s -- code missing for field %u\n",
  194.              rnames(rp), rfldno(rp));
  195.             abort();
  196.             break;
  197.           }
  198.           break;
  199.         
  200.         default:  /* programming error - missing context number */
  201.           fprintf (errout, "FATAL ERROR %s -- missing context number\n", 
  202.            rnames(rp));
  203.           abort();
  204.           break;
  205.         }
  206.         break;
  207.         
  208.       /* fatal errors (R_EINVMOD, R_EINVAL, R_ENOMEM) */
  209.       default:
  210.         fprintf(errout, "FATAL ERROR %s -- %s\n", rnames(rp), rerrstr(rp));
  211.         abort();
  212.         break;
  213.       }
  214.     }
  215.   
  216.   /* invalid record pointer */
  217.   } else {
  218.     switch (errno) {
  219.  
  220.     /* non-fatal errors */
  221.     case EACCES:
  222.     case EMFILE:
  223.       fprintf(errout, "WARNING: %s\n", strerror(errno));
  224.       break;
  225.  
  226.     /* fatal errors (EINVAL, ENOMEM) */
  227.     default:
  228.       fprintf(errout, "FATAL ERROR: %s\n", strerror(errno));
  229.       abort();
  230.       break;
  231.     }
  232.   }
  233. }
  234.  
  235. /****************************************************************************
  236. main
  237. *****************************************************************************/
  238. #include <io.h>
  239.  
  240. int main()
  241. {
  242.   int i;                        /* integer field */
  243.   unsigned int ui;              /* unsigned integer field */
  244.   long l;                       /* long field */
  245.   unsigned long ul;             /* unsigned long field */
  246.   float f;                      /* float field */
  247.   double d;                     /* double field */